perm filename F.DIF[CLS,LSP] blob
sn#827060 filedate 1986-10-27 generic text, type C, neo UTF8
COMMENT ā VALID 00019 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00004 00002 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00009 00003 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00012 00004 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00017 00005 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00022 00006 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00027 00007 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00032 00008 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00036 00009 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00040 00010 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00045 00011 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00050 00012 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00054 00013 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00058 00014 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00063 00015 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00067 00016 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00070 00017 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00076 00018 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00079 00019 1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
C00081 ENDMK
Cā;
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
**** File 1) FUNCTI.3[CLS,LSP]/1P/109L
1) the `next method' with the same arguments that this method received.
1) For the precise definition of `next method,' see the section ``Method
1) Combination.'' {\bf call-next-method} returns the value or values
1) returned by the method it calls. Further computation after {\bf
1) call-next-method} returns is possible, so this provides a general
1) imperative form of method-combination.
1) The type of method combination in use determines which kinds of methods
1) allow {\bf call-next-method} to be used. The default method combination
**** File 2) FUNCTI.4[CLS,LSP]/1P/109L
2) the "next method" with the same arguments that this method received.
2) For the precise definition of "next method" see the section "Method
2) Selection and Combination". {\bf call-next-method} returns the value or
2) values returned by the method it calls. Further computation after {\bf
2) call-next-method} returns is possible, so this provides a general
2) imperative form of method combination.
2) The type of method combination in use determines which kinds of methods
2) allow {\bf call-next-method} to be used. The default method combination
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/121L
1) method combination using the simple form of {\bf define-method-combination},
1) {\bf call-next-method} can be done in {\bf :around} methods only.
**** File 2) FUNCTI.4[CLS,LSP]/1P/121L
2) method combination using the short form of {\bf define-method-combination},
2) {\bf call-next-method} can be done in {\bf :around} methods only.
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/141L
1) The exact definition of `same arguments' is still under discussion and must
1) be clarified. This is particularly complicated in the face of optional,
1) rest, and keyword parameters. {\bf call-next-method} passes the actual values of
1) the parameter variables to the next method, except for keyword parameters,
1) which are passed via a rest-argument, not individually. Thus defaulted
1) optional parameters cannot be defaulted again by the next method, but
1) keyword parameters can be re-defaulted by the next method. If a parameter
1) variable is {\bf setq}'ed, or another variable with the same name is bound, the
1) variable value visible at the lexical position of the {\bf call-next-method} form
1) is used.
1) Possible extensions:
**** File 2) FUNCTI.4[CLS,LSP]/1P/141L
2) Neither argument defaulting, nor the use of {bf setq} or {bf let} on
2) variables with the same names as parameters affects {bf call-next-method}.
2) Possible extensions:
***************
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
**** File 1) FUNCTI.3[CLS,LSP]/1P/259L
1) The macro {\bf defclass} defines a new class, which is a template of a
1) new data type with named slots. It returns the name of the new class as
1) its result.
**** File 2) FUNCTI.4[CLS,LSP]/1P/251L
2) The macro {\bf defclass} defines a new class, which is a
2) new data type with named slots. It returns the class-object as
2) its result.
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/288L
1) slot-option ::= :default-value form |
1) :accessor generic-function-name |
1) :reader generic-function-name |
1) :initable keyword |
1) :allocation allocation-type |
1)
1) allocation-type ::= :instance | :class | :none | :dynamic
1) class-option ::= (:documentation string) |
1) (:accessor-prefix string-or-symbol) |
1) (:reader-prefix string-or-symbol) |
1) :initable-slots |
1) (:metaclass class-name) |
1) (:instantiable t-or-nil)
1) (:predicate symbol)
1) (:constructor symbol [boa-arglist])
1) boa-arglist ::= as you have it below
**** File 2) FUNCTI.4[CLS,LSP]/1P/280L
2) slot-option ::= :accessor generic-function-name |
2) :allocation allocation-type |
2) :default-value form |
2) :initable symbol |
2) :reader generic-function-name
2)
2) allocation-type ::= :instance | :class | :none | :dynamic
2) class-option ::= (:accessor-prefix string-or-symbol) |
2) (:constructor symbol [boa-arglist]) |
2) (:documentation string) |
2) :initable-slots |
2) (:instantiable t-or-nil)
2) (:metaclass class-name) |
2) (:predicate symbol)
2) (:reader-prefix string-or-symbol)
2) boa-arglist ::= as you have it below
***************
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
**** File 1) FUNCTI.3[CLS,LSP]/1P/352L
1) Each {\it slot-spec\/} includes the name of the slot, which is a
**** File 2) FUNCTI.4[CLS,LSP]/1P/344L
2) Each {\it super-class-name\/} is a non-null symbol naming a class to be
2) included as an integral part of this class. The class now being defined
2) will inherit characteristics (such as slots) and behavior (such as
2) methods) from each of its super-classes (and from their super-classes).
2) Each {\it super-class-name\/} must refer to a user-defined class, not a
2) built-in class.
2) Each {\it slot-spec\/} includes the name of the slot, which is a
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/367L
1) {\bf :default-value} {\it form\/} This is an alternate way for providing
1) a default initial value form. The {\it form\/} is evaluated every time it is
1) used.
1) {\bf :accessor} {\it generic-function-name\/} This specifies that a
1) method for an accessor function should automatically be generated for
1) this slot. An accessor is used to to read the value of this slot, and
1) {\bf setf} may be used with it to write the value of the slot. {\it
1) generic-function-name\/} must be a non-null symbol.
1) {\bf :reader} {\it non-null-symbol\/} This specifies that a method for a
1) reader function should automatically be generated for this slot. The
1) reader is a generic function named {\it non-null-symbol\/}. A reader is
1) used to read the value of the slot. This option does not cause a {\bf
1) setf} function to be defined. {\it generic-function-name\/} must be a
1) non-null symbol.
1) {\bf :initable} {\it keyword\/} This specifies a keyword to be used to
1) specify an initial value of this slot, when a new instance is being
1) made. {\it keyword\/} must be a non-nil symbol.
1) {\bf :allocation} {\it allocation-type} This specifies where storage is
1) allocated for this slot. The {\it allocation-type\/} can be one of
1) these keywords: {\bf :instance}, {\bf :class}, {\bf :dynamic}, {\bf :none}. The
1) semantics of these keywords are:
1) {\bf :instance} Storage is allocated in the instance itself; each
1) instance has its separate value for this slot. This is the default.
1) {\bf :class} Storage is allocated in the class. Thus a single value for
1) this slot is shared by all instances. The exact semantics of {\bf
1) :class} are still under discussion. For example, how are subclasses
1) handled? Does each subclass have a separate copy of this slot, or do
1) all subclasses share the same copy?
1) {\bf :dynamic} This option is still under discussion; it is not yet
1) clear whether it should be in the standard. The purpose of this option
1) is to specify: Storage is allocated in the instance at the time of the
1) first use of the slot. If the slot is initialized with a keyword
1) argument to {\bf make-instance}, the slot is allocated then. If the
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
**** File 2) FUNCTI.4[CLS,LSP]/1P/366L
2) {\bf :accessor} {\it generic-function-name\/} This specifies that a
2) method for an accessor function should automatically be generated for
2) this slot. An accessor is used to read the value of this slot, and
2) {\bf setf} may be used with it to write the value of the slot. {\it
2) generic-function-name\/} must be a non-null symbol.
2) {\bf :allocation} {\it allocation-type} This specifies where storage is
2) allocated for this slot. The {\it allocation-type\/} can be one of
2) these keywords: {\bf :instance}, {\bf :class}, {\bf :dynamic}, {\bf
2) :none}. The semantics of these keywords are:
2) {\bf :allocation :instance} Storage is allocated in the instance itself;
2) each instance has its separate value for this slot. This is the
2) default.
2) {\bf :allocation :class} Storage is allocated in the class. Thus a
2) single value for this slot is shared by all instances. Class slots
2) (like other slots) are inherited by subclasses of this class. The state
2) associated with a class slot is stored only where it is explicitly
2) specified in the class. If a local description of a slot is provided,
2) it completely overrides an inherited description of a component class.
2) {\bf :allocation :dynamic} This option is still under discussion; it is
2) not yet clear whether it should be in the standard. The purpose of this
2) option is to specify: Storage is allocated in the instance at the time
2) of the first use of the slot. If the slot is initialized with a keyword
2) argument to {\bf make-instance}, the slot is allocated then. If the
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/413L
1) {\bf :none} No storage is to be allocated; the slot should not exist in
1) instances of this class. This is used to override inheritance of slots
1) defined by a super-class.
1) Each {\it super-class-name\/} is a non-null symbol naming a class to be
1) included as an integral part of this class. The class now being defined
1) will inherit characteristics (such as slots) and behavior (such as
1) methods) from each of its super-classes. Each {\it super-class-name\/}
1) must refer to a user-defined class, not a built-in class. A built-in
1) class corresponds to one of the predefined Common Lisp type specifiers;
1) for example {\bf array} is a built-in class for objects of type {\bf array}.
1) Each {\it class-option\/} is an option that refers to the class.
1) The set of defined options is:
1) (:documentation string) This enables you to specify an arbitrary string
1) as documentation for this class. The form (documentation class-name
1) 'type) retrieves this string.
1) (:instantiable t-or-nil) This option has not been discussed.
1) This specifies whether it is possible to directly
1) instantiate this class with {\bf make-instance}. If {\bf :instantiable} is
1) {\bf nil}, the class cannot be instantiated and is termed an {\bf abstract
1) class}. The default value of {\bf :instantiable} is {\bf t}.
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
1) (:predicate symbol) This option has not been discussed yet. This
1) generates a predicate function named {\it symbol\/}, which must be a
1) non-nil symbol. The predicate function takes one argument, an object,
1) and returns {\bf t} if the object is of this class, {\bf nil} otherwise.
1) (:accessor-prefix string-or-symbol) This causes a method for an accessor
**** File 2) FUNCTI.4[CLS,LSP]/1P/399L
2) {\bf :allocation :none} No storage is to be allocated; the slot should
2) not exist in instances of this class. This is used to override
2) inheritance of slots defined by a super-class.
2) {\bf :default-value} {\it form\/} This is an alternate way for providing
2) a default initial value form. The {\it form\/} is evaluated every time
2) it is used.
2) {\bf :initable} {\it symbol\/} This specifies a non-nil symbol to be used to
2) specify an initial value of this slot, when a new instance is being
2) made. {\it symbol\/} can be supplied as an {bf &key} argument to {bf
2) make-instance}. (This is still under discussion.)
2) {\bf :reader} {\it non-null-symbol\/} This specifies that a method for a
2) reader function should automatically be generated for this slot. The
2) reader is a generic function named {\it non-null-symbol\/}. A reader is
2) used to read the value of the slot. This option does not cause a {\bf
2) setf} function to be defined. {\it generic-function-name\/} must be a
2) non-null symbol.
2) Each {\it class-option\/} is an option that refers to the class.
2) The set of defined options is:
2) (:accessor-prefix string-or-symbol) This causes a method for an accessor
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/448L
1) the slot.
1) (:reader-prefix string-or-symbol) This causes a method for a reader
1) generic function to be generated automatically for each slot. The
1) reader is used to read the value of a slot. This option does not cause
1) a {\bf setf} function to be defined. The name of each reader is the
1) prefix {\it string-or-symbol\/} followed by the name of the slot.
1) :initable-slots This specifies that it is allowed to initialize all
1) slots of this class. The initialization can be done by providing the
1) keyword with the same name as the slot, followed by the slot's initial
1) value as an argument to {\bf make-instance}, or by including the keyword
1) and value in the {\bf :default-init-plist}.
1) (:default-init-plist {keyword argument}*) This option is still under
**** File 2) FUNCTI.4[CLS,LSP]/1P/427L
2) the slot, interned in the package current at the time {bf defclass} is
2) macro-expanded.
2) (:constructor symbol [boa-arglist]) This causes a constructor function
2) named {\it symbol\/} to be generated automatically. The constructor is
2) used to make a new instance of the class. If no {\it boa-arglist\/} is
2) present, the constructor takes keyword arguments. If {\it
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
2) boa-arglist\/} is present, it describes the arguments to the
2) constructor. The syntax of the {\bf :constructor\/} option to {\bf
2) defclass} is the same as that of the {\bf defstruct :constructor} option
2) described in ``Common Lisp the Language.''
2) (:default-init-plist {keyword argument}*) This option is still under
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/474L
1) (:init-keywords {keyword}*) This option is still under discussion; it is
**** File 2) FUNCTI.4[CLS,LSP]/1P/451L
2) (:documentation string) This enables you to specify an arbitrary string
2) as documentation for this class. The form (documentation class-name
2) 'type) retrieves this string.
2) (:init-keywords {keyword}*) This option is still under discussion; it is
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/485L
1) (:constructor symbol [boa-arglist]) This causes a constructor function
1) named {\it symbol\/} to be generated automatically. The constructor is
1) used to make a new instance of the class. If no {\it boa-arglist\/} is
1) present, the constructor takes keyword arguments. If {\it
1) boa-arglist\/} is present, it describes the arguments to the
1) constructor. The syntax of the {\bf :constructor\/} option to {\bf
1) defclass} is the same as that of the {\bf defstruct :constructor} option
1) described in ``Common Lisp the Language.''
1) (:metaclass class-name) This specifies that this class has a different
**** File 2) FUNCTI.4[CLS,LSP]/1P/466L
2) :initable-slots This specifies that it is allowed to initialize all
2) slots of this class. The initialization can be done by providing the
2) keyword with the same name as the slot, followed by the slot's initial
2) value as an argument to {\bf make-instance}, or by including the keyword
2) and value in the {\bf :default-init-plist}.
2) (:instantiable t-or-nil) This option has not been discussed.
2) This specifies whether it is possible to directly
2) instantiate this class with {\bf make-instance}. If {\bf :instantiable} is
2) {\bf nil}, the class cannot be instantiated and is termed an {\bf abstract
2) class}. The default value of {\bf :instantiable} is {\bf t}.
2) (:metaclass class-name) This specifies that this class has a different
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/501L
1) \label Values:
**** File 2) FUNCTI.4[CLS,LSP]/1P/484L
2) (:predicate symbol) This option has not been discussed yet. This
2) generates a predicate function named {\it symbol\/}, which must be a
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
2) non-nil symbol. The predicate function takes one argument, an object,
2) and returns {\bf t} if the object is of this class, {\bf nil} otherwise.
2) (:reader-prefix string-or-symbol) This causes a method for a reader
2) generic function to be generated automatically for each slot. The
2) reader is used to read the value of a slot. This option does not cause
2) a {\bf setf} function to be defined. The name of each reader is the
2) prefix {\it string-or-symbol\/} followed by the name of the slot,
2) interned in the package current at the time {bf defclass} is
2) macro-expanded.
2) \label Values:
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/527L
1) - All the component classes of a class must be defined before it is
**** File 2) FUNCTI.4[CLS,LSP]/1P/523L
2) - It is not required that the component classes of a class be
2) defined before this {bf defclass} is evaluated.
2) - All the component classes of a class must be defined before it is
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/537L
1) Some implementations might add other options to {\bf defclass}. Therefore it is
1) required that all implementations signal an error if they observe an option
1) that is not implemented locally.
1) If no default value for a slot is specified either in the {\bf defclass} or the
**** File 2) FUNCTI.4[CLS,LSP]/1P/536L
2) Slot-options and class-options are inherited by a class from its
2) components. However, a class can override an option that would be
2) inherited from a component class simply by providing that option in the
2) {bf defclass} form.
2) Some implementations might add other options to {\bf defclass}. Therefore it is
2) required that all implementations signal an error if they observe a
2) class-option or a slot-option that is not implemented locally.
2) If no default value for a slot is specified either in the {\bf defclass} or the
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/560L
1) \label See Also:
**** File 2) FUNCTI.4[CLS,LSP]/1P/564L
2) The following slot-options may appear more than once:
2) {bf :accessor}
2) {bf :reader}
2) {bf :initable}
2) The following class-options may appear more than once:
2) {bf :accessor-prefix}
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
2) {bf :constructor}
2) {bf :default-init-plist}
2) {bf :init-keywords}
2) {bf :predicate}
2) {bf :reader-prefix}
2) No other slot-option or class-option may appear more than once in a
2) single {bf defclass} form.
2) \label See Also:
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/591L
1) option ::= (:documentation string) | string
1) (:method-combination name {argument}*)
1) (declare {declaration}+)
1) (:argument-precedence-order {parameter-name}+)
1) (:interface {form}+)
1) (:method-arguments {form}+)
1) (:generic-function-class class-name)
1) (:method-class class-name)
1) \Defmac {defgeneric} {name lambda-list \ttbrac{documentation} \star{\curly{option}}}
**** File 2) FUNCTI.4[CLS,LSP]/1P/613L
2) option ::= (:argument-precedence-order {parameter-name}+)
2) (declare {declaration}+)
2) (:documentation string) | string
2) (:generic-function-class class-name)
2) (:interface {form}+)
2) (:method-arguments {lambda-list}+)
2) (:method-class class-name)
2) (:method-combination name {argument}*)
2) \Defmac {defgeneric} {name lambda-list \ttbrac{documentation} \star{\curly{option}}}
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/614L
1) 2. Optionals (including keyword arguments)may not have default-forms ur
1) use supplied-p, and hence the symbol does not imply a default value
1) of NIL. Note that optionals in the methods can have default forms
**** File 2) FUNCTI.4[CLS,LSP]/1P/637L
2) 2. Optionals (including keyword arguments) may not have default-forms
2) or use supplied-p. Thus the symbol does not imply a default value
2) of NIL. Note that optionals in the methods can have default forms
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/621L
1) (:documentation string) | string
1) Associates a documentation string with the generic
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
1) function. The form (documentation generic-function-name
1) 'function) retrieves this string.
1) (:method-combination name {argument}*)
1) Indicates that the generic function uses the type of method
1) combination named by name. The arguments depend on the
1) type of method combination. The most common argument is
1) one to specify the order of methods, which is either
1) :most-specific-first or :most-specific-last. The default
1) method combination type is :daemon, with the
1) :most-specific-first order.
1) (declare {declaration}+)
1) Declarations that apply to the whole function (as opposed
1) to declarations of variables) are permitted. The only
1) declaration in this standard is optimize, which can have
**** File 2) FUNCTI.4[CLS,LSP]/1P/644L
2) (:argument-precedence-order {parameter-name}+)
2) This option alters the default way of selecting methods.
2) By default, all required arguments are considered
2) from left to right; each required argument has
2) precedence over those to its right. When this option is
2) used, each required argument should be included as a
2) parameter-name, so the full precedence order is supplied.
2) (declare {declaration}+)
2) Declarations that apply to the whole function (as opposed
2) to declarations of variables) are permitted. Type
2) declarations of the parameters are allowed; some Common
2) Lisp implementations use this when compiling calls to
2) the generic function. The only
2) declaration in this standard is optimize, which can have
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/641L
1) space; it has no affect on individual methods. Some
1) implementations might support other declarations. If an
**** File 2) FUNCTI.4[CLS,LSP]/1P/661L
2) space; it has no effect on individual methods. Some
2) implementations might support other declarations. If an
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/647L
1) (:argument-precedence-order {parameter-name}+)
1) This option alters the default way of selecting methods.
1) By default, all required arguments are considered
1) from left to right; each required argument has
1) precedence over those to its right. When this option is
1) used, each required argument should be included as a
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
1) parameter-name, so the full precedence order is supplied.
1) (:interface {form}+)
**** File 2) FUNCTI.4[CLS,LSP]/1P/667L
2) (:documentation string) | string
2) Associates a documentation string with the generic
2) function. The form (documentation generic-function-name
2) 'function) retrieves this string.
2) (:generic-function-class class-name)
2) Specifies that this generic function has a different
2) implementation than the system-provided default. If you
2) have invented a new generic function class, this option is
2) the mechanism for creating a generic function of the new
2) class. class-name is the name of a class that is capable
2) of being the class of a generic function.
2) (:interface {form}+)
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/663L
1) for any other purpose. Another use of this option is to
1) extend a generic function so it can also be used for
1) objects that are not instances of a built-in class.
1) Inside the forms you can trigger the generic dispatch with
1) (call-methods args...) or (apply-methods args...).
1) apply-methods treats the last argument as a list of
1) arguments just like apply. call-methods and apply-methods
1) are defined lexically only inside the :interface option.
1) (:method-arguments {form}+)
1) This option is under discussion.
**** File 2) FUNCTI.4[CLS,LSP]/1P/688L
2) for any other purpose.
2) Inside the forms you can trigger the generic dispatch with
2) (call-next-method args...) or (apply-next-method args...).
2) apply-next-method treats the last argument as a list of
2) arguments just like apply.
2) (:method-arguments {lambda-list}+)
2) This option is under discussion.
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/678L
1) specified at the top of the defgeneric form. The
1) :method-arguments option is meaningful only in connection
1) with the :inteface option.
1) (:generic-function-class class-name)
1) Specifies that this generic function has a different
1) implementation than the system-provided default. If you
1) have invented a new generic function class, this option is
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
1) the mechanism for creating a generic function of the new
1) class. class-name is the name of a class that is capable
1) of being the class of a generic function.
1) (:method-class class-name)
**** File 2) FUNCTI.4[CLS,LSP]/1P/700L
2) specified at the top of the defgeneric form. If
2) :interface is also specified, it provides the
2) translation from generic-function arguments to
2) method-arguments. If :interface is not specified, the
2) arguments are permuted according to matching names, and
2) all names in the :method-arguments lambda-list must also
2) appear in the generic-function's lambda-list. For
2) example:
2)
2) (defgeneric foo (x y &optional z)
2) (:method-arguments y x z))
2) (:method-class class-name)
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/701L
1) \label Values:
**** File 2) FUNCTI.4[CLS,LSP]/1P/723L
2) (:method-combination name {argument}*)
2) Indicates that the generic function uses the type of method
2) combination named by name. The arguments depend on the
2) type of method combination. The most common argument is
2) one to specify the order of methods, which is either
2) :most-specific-first or :most-specific-last. The default
2) method combination type is :daemon, with the
2) :most-specific-first order.
2) \label Values:
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/740L
1) function. The new generic function object is returned as the result.
1) \label Syntax:
**** File 2) FUNCTI.4[CLS,LSP]/1P/771L
2) function. A {\bf setf} generic function is called in an expression such as:
2) ({bf setf} ({\it generic-function-name arguments...\/}) {\it new-value\/})
2) The new generic function object is returned as the result.
2) \label Syntax:
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/751L
1) (:method-arguments {form}+)
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
1) (:generic-function-class class-name)
**** File 2) FUNCTI.4[CLS,LSP]/1P/786L
2) (:method-arguments {lambda-list}+)
2) (:generic-function-class class-name)
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/757L
1) {\it generic-function-name} is a non-null symbol naming an accessor
1) generic function.
1) The {\it lambda-list\/} argument is the same as for {\bf defgeneric}.
**** File 2) FUNCTI.4[CLS,LSP]/1P/792L
2) {\it generic-function-name} is a non-null symbol naming a generic
2) function.
2) The {\it lambda-list\/} argument is the same as for {\bf defgeneric}.
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/782L
1) \endcom
**** File 2) FUNCTI.4[CLS,LSP]/1P/816L
2) {\bf defmethod}
2) \endcom
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/818L
1) The argument list of the method must be congruent. with the argument
1) list of the generic function. If this condition does not hold, an error is
1) signalled. See ``Remarks"'' for a definition of congruency in this
1) context.
1) [The following is under discussion: A generic function of the given name
**** File 2) FUNCTI.4[CLS,LSP]/1P/854L
2) The argument list of the method must be congruent with the argument
2) list of the generic function. If this condition does not hold, an error is
2) signalled. See "Generic Functions and Methods" for
2) a definition of congruency in this context.
2) [The following is under discussion: A generic function of the given name
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/861L
1) qualifier A non-null symbol OR a non-null atom (not agreed yet), used
1) by method combination to identify the method. For
1) example, :before, :after, or :around.
1) specialized-lambda-list
**** File 2) FUNCTI.4[CLS,LSP]/1P/897L
2) qualifier A object used by method combination to identify the
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
2) method. For example, :before, :after, or :around.
2) qualifier cannot be a list (or NIL, the empty list).
2) specialized-lambda-list
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/868L
1) specialized-variables so that method selection uses that
1) argument. A specialized-variable is a list such as:
1) (variable-name parameter-specifier). A specialized-variable
1) may be used wherever a lambda-list allows only a
1) variable and not a list. Only required parameters may
1) be specialized. [Note that the specialization on optional
1) parameters is still under discussion.]
1)
1) parameter-specifier
1) parameter-specifier can be a user-defined class, or the name
1) of a structure defined by defstruct if the :type option was
1) not used, or a Common Lisp type specifier from the subset
1) listed here:
1) array integer ratio
1) bit-vector list rational
1) character long-float readtable
1) compiled-function null sequence
1) complex number short-float
1) cons package single-float
1) double-float pathname string
1) float quote symbol
1) hash-table random-state t
1) vector
1) Note that the use of t as a parameter-specifier defines a
1) default method. Such a method is selected only when no
1) more specific method for the generic function is defined.
1) Quote is used with an object to indicate that this
1) argument must be bound to the quoted object for this
1) method to be applicable.
1) \label Values:
**** File 2) FUNCTI.4[CLS,LSP]/1P/904L
2) specialized parameters so that method selection uses that
2) argument. A specialized parameter is a list such as:
2) (variable-name parameter-specializer). Only required
2) parameters may be specialized. [Note that the
2) specialization on optional parameters is still under
2) discussion.]
2)
2) parameter-specializer
2) parameter-specializer can be symbol that names a
2) user-defined class, or a structure defined by defstruct
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
2) if the :type option was not used, or a class
2) corresponding to a Common Lisp type specifier. Note
2) that not all Common Lisp types have a corresponding
2) class. The section "Generic Functions and Methods"
2) lists the Common Lisp types that have corresponding
2) classes.
2) parameter-specializer can also be (QUOTE object) to
2) indicate that this argument must be EQL to the quoted
2) object for this method to be applicable.
2) Note that the use of t as a parameter-specializer defines a
2) default method. Such a method is selected only when no
2) more specific method for the generic function is defined.
2) \label Values:
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/914L
1) All methods of a generic function must have congruent argument lists.
1) In this context, congruency implies that the system can determine whether
1) a call is syntactically correct. The rules are:
1) 1. Methods must have the same number of required and optional
1) arguments.
1) 2. Methods must allow exactly the same keywords, or use
1) \&allow-other-keys appropriately.
1) 3. Either all methods have use \&rest or none of them use it.
1) \endcom
**** File 2) FUNCTI.4[CLS,LSP]/1P/942L
2) \label See Also:
2) See the section "Generic Functions and Methods".
2) \endcom
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/933L
1) The macro {\bf defmethod-setf} defines a {\bf setf} method.
1) \label Syntax:
**** File 2) FUNCTI.4[CLS,LSP]/1P/953L
2) The macro {\bf defmethod-setf} defines a method for a {\bf setf} generic
2) function. A {\bf setf} generic function is called in an expression such as:
2) ({bf setf} ({\it generic-function-name arguments...\/}) {\it new-value\/})
2) \label Syntax:
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/1001L
1) \label Syntax:
**** File 2) FUNCTI.4[CLS,LSP]/1P/1024L
2) The existing describe function is required to be replaced by this generic
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
2) function.
2) (defgeneric describe (object))
2) Each implementation is required to replace its former implementation of
2) describe with one or more methods. Exactly which classes have methods for
2) describe is not specified.
2) Users can also write methods for describe; these methods must conform to
2) the Common Lisp definition of describe in Common Lisp the Language. A
2) user-defined class without a method for describe inherits an appropriate
2) system-defined method.
2) \label Syntax:
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/1007L
1) \label Values:
1) \label Examples:
**** File 2) FUNCTI.4[CLS,LSP]/1P/1044L
2) {\it object\/} is any Lisp object.
2) \label Values:
2) As described in {\it Common Lisp the Language\/}.
2) \label Examples:
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/1289L
1) \begincom{remove-class}
1) \label Purpose:
1) \label Syntax:
1) \Defun {remove-class} {class}
1) \label Arguments:
**** File 2) FUNCTI.4[CLS,LSP]/1P/1327L
2) \begincom{print-object}
2) \label Purpose:
2) PRINT-OBJECT outputs the printed representation of the object onto the
2) stream. PRINT-OBJECT is called by the print system, and should not be
2) called by the user. A user-defined class can have a method for
2) PRINT-OBJECT that defines its printed representation. If it has no method,
2) it inherits a system-defined method which produces a default
2) printed-representation, perhaps using a syntax such as #<...> that is not
2) understood by the reader.
2) \label Syntax:
2) (defgeneric print-object (object stream))
2) \label Arguments:
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/1303L
1) \endcom
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
**** File 2) FUNCTI.4[CLS,LSP]/1P/1349L
2) \label Remarks:
2) Each PRINT-OBJECT method must obey the print-control special variables
2) as documented in Common Lisp the Language pp. 370-373. The specific
2) details are:
2) *PRINT-ESCAPE* Each method must implement this.
2) *PRINT-PRETTY* This can be ignored by most methods other than the one for
2) lists.
2) *PRINT-CIRCLE* This is handled by the printer and can be ignored by
2) methods.
2) *PRINT-LEVEL* The printer takes care of this automatically, provided that
2) each method handles exactly one level of structure and
2) calls write (or an equivalent function) recursively if
2) there are more structural levels. The printer's decision
2) of whether an object has components, and therefore should
2) not be printed when the printing depth is not less than
2) *PRINT-LEVEL*, is implementation-dependent. In some
2) implementations its PRINT-OBJECT method is not called, in
2) others the method is called and the determination that the
2) object has components is based on what it tries to output
2) to the stream.
2) *PRINT-LENGTH* Methods that produce output of indefinite length must obey
2) this, but most methods other than the one for lists can
2) ignore it.
2) *PRINT-BASE*, *PRINT-RADIX*, *PRINT-CASE*, *PRINT-GENSYM*, and
2) *PRINT-ARRAY* apply to specific types of objects and are handled by the
2) methods for those objects.
2) In general, the printer and the PRINT-OBJECT methods should not rebind the
2) print-control variables as they recurse through the structure, but this is
2) necessarily implementation-dependent.
2) In some implementations the stream argument passed to a PRINT-OBJECT method
2) is not the original stream, but is an intermediate stream that implements
2) part of the printer, so methods should not depend on the identity of this
2) stream.
2) All of the existing printing functions (write, prin1, print, princ, pprint,
2) write-to-string, prin1-to-string, princ-to-string, the format ~S and ~A
2) operations, and the format ~B, ~D, ~E, ~F, ~G, ~$, ~O, ~R, and ~X
2) operations when they encounter a non-numeric value) are required to be
2) changed to go through the PRINT-OBJECT generic function. Each
2) implementation is required to replace its former implementation of printing
2) with one or more PRINT-OBJECT methods. Exactly which classes have methods
2) for PRINT-OBJECT is not specified; it would be valid for an implementation
2) to have one default method that is inherited by all system-defined classes.
2) References: See MIT AI Memo 816, December 1984, by Richard C. Waters for a
2) discussion of PP, one of the better designed Lisp printers. It handles
2) *PRINT-LEVEL* and *PRINT-LENGTH* invisibly to the PRINT-OBJECT methods.
2) See also the inconclusive discussion on printing, *PRINT-LEVEL*, and
2) recursion on the Common-Lisp mailing list around 21 November 1985 for
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
2) additional background.
2) \endcom
2) \begincom{remove-class}
2) \label Purpose:
2) \label Syntax:
2) \Defun {remove-class} {class}
2) \label Arguments:
2) \label Values:
2) \label Examples:
2) \endcom
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/1463L
1) {\it options\/}::$=$ {\tt\vtop{\hbox{:use-accessor {\it t-or-nil\/} $\vert$}
1) \hbox{:class {\it class-name\/} $\vert$}
**** File 2) FUNCTI.4[CLS,LSP]/1P/1587L
2) {\it options\/}::$=$ {\tt\vtop{\hbox{:use-accessors {\it t-or-nil\/} $\vert$}
2) \hbox{:class {\it class-name\/} $\vert$}
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/1512L
1) (defclass point ((x 0) (y 0)) ()
1) (:accessor-prefix point-))
**** File 2) FUNCTI.4[CLS,LSP]/1P/1636L
2) (defclass point () ((x 0) (y 0))
2) (:accessor-prefix point-))
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/1524L
1) ;;; set the y coord of p1 to the y of p2, its reference.
1) ;;; slots of p1 are accessed using the slot names
1) ;;; slots of p2 are accessed using ref-<slot-name>
1) (with-slots (p1 :prefix p1- (p2 :prefix p2-))
1) (setf p1-y p2-y)))
**** File 2) FUNCTI.4[CLS,LSP]/1P/1648L
2) (with-slots ((p1 :prefix p1-) (p2 :prefix p2-))
2) (setf p1-y p2-y)))
***************
**** File 1) FUNCTI.3[CLS,LSP]/1P/1541L
1) with-slots} forms; it is also allowed to use {\bf setq}. Note that using
1) {\bf setf} or {\bf setq} with a variable name does not affect the meaning
1) of the slot itself.
1) It is an error if the class of {\it instance} cannot be inferred from the
1) FUNCTI.3[CLS,LSP] and 2) FUNCTI.4[CLS,LSP] 10-27-86 18:00 pages 1,1
1) lexical context in which it occurs. That is, if more than one {\it
1) instance\/} is given, they must have disjoint sets of names for slots to
1) avoid ambiguity of reference, or the {\bf :prefix} option must be used
1) to distinguish between the names. If any ambiguity is detected, {\bf
1) with-slots} signals an error.
1) \endcom
**** File 2) FUNCTI.4[CLS,LSP]/1P/1662L
2) with-slots} forms; it is also allowed to use {\bf setq}.
2) It is an error if the class of {\it instance} cannot be inferred from
2) the lexical context in which it occurs. If any ambiguity is detected,
2) {\bf with-slots} signals an error.
2) \endcom
***************